home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Resources / Chat & Communication / Digsby build 37 / digsby_setup.exe / lib / gui / input / inputmanager.pyo (.txt) < prev   
Encoding:
Python Compiled Bytecode  |  2008-10-13  |  11.1 KB  |  357 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.5)
  3.  
  4. from __future__ import with_statement
  5. from traceback import print_exc
  6. from collections import defaultdict
  7. from util import Delegate, import_function, memoize
  8. from util.merge import merge_keys
  9. from prefs import flatten
  10. import wx
  11. from wx import WXK_F1, WXK_F24, wxEVT_KEY_DOWN
  12. from logging import getLogger
  13. log = getLogger('input')
  14. DEBUG = log.debug
  15.  
  16. class InputManager(object):
  17.     
  18.     def __init__(self):
  19.         self.reset()
  20.  
  21.     
  22.     def reset(self):
  23.         self.handlers = defaultdict(Delegate)
  24.         self.actions = defaultdict(dict)
  25.         self.contexts = []
  26.         self.context_lookups = []
  27.         self.actionnames = { }
  28.         self.context_cache = { }
  29.         self.bound = False
  30.  
  31.     
  32.     def AddGlobalContext(self, name, contextstr):
  33.         self.context_lookups.append((contextstr.lower(), GlobalContext()))
  34.         self.context_cache.clear()
  35.         self.resolve_actions()
  36.  
  37.     
  38.     def AddClassContext(self, name, contextstr, cls):
  39.         self.context_lookups.append((contextstr.lower(), ClassContext(name, cls)))
  40.         self.context_cache.clear()
  41.         self.resolve_actions()
  42.  
  43.     
  44.     def AddKeyboardShortcut(self, actionname, accels):
  45.         keys = (KeyActionSet,)((lambda .0: for accel in .0:
  46. (keycodes(accel), actionname))(accels.split(',')))
  47.         self.actionnames[actionname.lower()] = keys
  48.         self.resolve_actions()
  49.  
  50.     
  51.     def LoadKeys(self, filepath):
  52.         addkey = self.AddKeyboardShortcut
  53.         import syck
  54.         
  55.         try:
  56.             f = _[2]
  57.             for actionname, accels in flatten(merge_keys(syck.load(f))):
  58.                 addkey(actionname, accels)
  59.         finally:
  60.             pass
  61.  
  62.  
  63.     
  64.     def resolve_actions(self):
  65.         if not self.bound:
  66.             return None
  67.         
  68.         contexts = set()
  69.         find_context = self.find_context
  70.         for actionname, actionset in self.actionnames.iteritems():
  71.             context = find_context(actionname)
  72.             if context is not None:
  73.                 
  74.                 try:
  75.                     keyactions = self.actions[wxEVT_KEY_DOWN][context]
  76.                 except KeyError:
  77.                     keyactions = self.actions[wxEVT_KEY_DOWN][context] = KeyActionSet()
  78.  
  79.                 keyactions.update(actionset)
  80.                 contexts.add(context)
  81.                 continue
  82.         
  83.         self.contexts = sorted(contexts, reverse = True)
  84.  
  85.     
  86.     def AddActionCallback(self, actionname, callback):
  87.         actionname = actionname.lower()
  88.         if isinstance(callback, basestring):
  89.             callback = LazyStringImport(callback)
  90.         
  91.         if actionname not in self.handlers:
  92.             self.handlers[actionname] = Delegate([
  93.                 callback])
  94.         else:
  95.             self.handlers[actionname] += callback
  96.         self.resolve_actions()
  97.  
  98.     
  99.     def BindWxEvents(self, evt_handler):
  100.         if self.bound is not evt_handler:
  101.             evt_handler.Bind(wx.EVT_KEY_DOWN, self.handle_event)
  102.             self.bound = evt_handler
  103.         
  104.         self.resolve_actions()
  105.  
  106.     
  107.     def find_context(self, actionname):
  108.         if actionname in self.context_cache:
  109.             return self.context_cache[actionname]
  110.         
  111.         actionname = actionname.lower()
  112.         startswith = actionname.startswith
  113.         found = _[1]
  114.         found.sort(key = (lambda s: len(s[0])), reverse = True)
  115.         context = [] if found else None
  116.         return self.context_cache.setdefault(actionname, context)
  117.  
  118.     
  119.     def handle_event(self, e):
  120.         contexts = self.contexts
  121.         for win in child_and_parents(e.EventObject):
  122.             for context in contexts:
  123.                 if context(win):
  124.                     if self.invoke_actions(context, e, win) is False:
  125.                         return None
  126.                     
  127.                 self.invoke_actions(context, e, win) is False
  128.             
  129.         
  130.         e.Skip()
  131.  
  132.     
  133.     def invoke_actions(self, context, e, win):
  134.         
  135.         try:
  136.             actionset = self.actions[e.EventType][context]
  137.         except KeyError:
  138.             return None
  139.  
  140.         
  141.         try:
  142.             actionname = actionset(e, win)
  143.             if actionname is False:
  144.                 return None
  145.             elif actionname is not None:
  146.                 return self.event(actionname, win)
  147.         except Exception:
  148.             print_exc()
  149.  
  150.  
  151.     
  152.     def event(self, actionname, *a, **k):
  153.         
  154.         try:
  155.             DEBUG('firing action %r', actionname)
  156.             action_delegate = self.handlers[actionname]
  157.             DEBUG(' callbacks: %r', action_delegate)
  158.         except KeyError:
  159.             pass
  160.  
  161.         
  162.         try:
  163.             if action_delegate:
  164.                 action_delegate(*a, **k)
  165.                 return False
  166.         except Exception:
  167.             print_exc()
  168.  
  169.  
  170.  
  171.  
  172. class Context(object):
  173.     __slots__ = [
  174.         'name']
  175.     priority = 0
  176.     
  177.     def __init__(self, name):
  178.         self.name = name
  179.  
  180.     
  181.     def __call__(self):
  182.         raise NotImplementedError('Context subclasses must implement __call__')
  183.  
  184.     
  185.     def __cmp__(self, other):
  186.         return cmp(self.priority, other.priority)
  187.  
  188.     
  189.     def __hash__(self):
  190.         return hash(id(self))
  191.  
  192.  
  193.  
  194. class WindowNameContext(Context):
  195.     __slots__ = [
  196.         'window_name']
  197.     priority = 100
  198.     
  199.     def __init__(self, name, window_name):
  200.         Context.__init__(self, name)
  201.         self.window_name = window_name
  202.  
  203.     
  204.     def __call__(self, window):
  205.         return window.Name == self.window_name
  206.  
  207.     
  208.     def __repr__(self):
  209.         return '<WindowNameContext %r>' % self.window_name
  210.  
  211.  
  212.  
  213. class ClassContext(Context):
  214.     __slots__ = [
  215.         'cls']
  216.     priority = 90
  217.     
  218.     def __init__(self, name, cls):
  219.         Context.__init__(self, name)
  220.         self.cls = cls
  221.  
  222.     
  223.     def __call__(self, window):
  224.         return isinstance(window, self.cls)
  225.  
  226.     
  227.     def __repr__(self):
  228.         return '<ClassContext %r>' % self.cls
  229.  
  230.  
  231.  
  232. class GlobalContext(Context):
  233.     priority = 10
  234.     
  235.     def __init__(self, name = 'Global Shortcuts'):
  236.         Context.__init__(self, name)
  237.  
  238.     
  239.     def __call__(self, window, tlw = wx.TopLevelWindow):
  240.         return isinstance(window, tlw)
  241.  
  242.     
  243.     def __repr__(self):
  244.         return '<GlobalContext %s>' % self.name
  245.  
  246.  
  247.  
  248. class KeyActionSet(dict):
  249.     
  250.     def __call__(self, e, win):
  251.         keycode = e.KeyCode
  252.         if keycode <= keycode:
  253.             pass
  254.         elif keycode <= WXK_F24:
  255.             pass
  256.         elif keycode < 256:
  257.             keycode = ord(chr(keycode).upper())
  258.         
  259.         key = (e.Modifiers, keycode)
  260.         return self.get(key, None)
  261.  
  262.  
  263.  
  264. def child_and_parents(win):
  265.     yield win
  266.     win = getattr(win, 'Parent', None)
  267.     while win is not None:
  268.         yield win
  269.         win = win.Parent
  270.  
  271.  
  272. def _accelerr(s):
  273.     raise ValueError('illegal accelerator: like "cmd+k" or "k" (you gave "%s")' % s)
  274.  
  275. replacements = {
  276.     'backspace': 'back',
  277.     'capslock': 'capital',
  278.     '=': 43 }
  279.  
  280. def keycodes(s, accel = True):
  281.     if isinstance(s, basestring):
  282.         s = s.strip()
  283.         seq = s.split('+')
  284.         for i, _elem in enumerate(seq[:]):
  285.             if _elem == '':
  286.                 seq[i] = '+'
  287.                 continue
  288.         
  289.         if len(seq) == 1:
  290.             modifiers = [
  291.                 'normal']
  292.             key = s
  293.         else:
  294.             modifiers = seq[:-1]
  295.             key = seq[-1]
  296.     elif not isinstance(s, int):
  297.         _accelerr(s)
  298.     
  299.     modifiers = [
  300.         'normal']
  301.     key = s
  302.     modifier = 0
  303.     PREFIX = None if accel else 'MOD_'
  304.     for mod in modifiers:
  305.         modifier |= getattr(wx, PREFIX + mod.upper())
  306.     
  307.     if isinstance(key, basestring):
  308.         if len(key) == 1 and key not in replacements:
  309.             key = ord(key.upper())
  310.         else:
  311.             key = replacements.get(key.lower(), key)
  312.             if isinstance(key, basestring):
  313.                 
  314.                 try:
  315.                     key = getattr(wx, 'WXK_' + replacements.get(key.lower(), key).upper())
  316.                 except AttributeError:
  317.                     _accelerr(s)
  318.                 except:
  319.                     None<EXCEPTION MATCH>AttributeError
  320.                 
  321.  
  322.             None<EXCEPTION MATCH>AttributeError
  323.     
  324.     return (modifier, key)
  325.  
  326. keycodes = memoize(keycodes)
  327.  
  328. class LazyStringImport(str):
  329.     
  330.     def __call__(self, *a, **k):
  331.         
  332.         try:
  333.             return self.cb()
  334.         except TypeError:
  335.             e = None
  336.             if e.message.endswith('takes exactly 1 argument (0 given)'):
  337.                 return self.cb(*a, **k)
  338.             else:
  339.                 raise 
  340.         except:
  341.             e.message.endswith('takes exactly 1 argument (0 given)')
  342.  
  343.  
  344.     
  345.     def cb(self):
  346.         
  347.         try:
  348.             return self._cb
  349.         except AttributeError:
  350.             self._cb = import_function(self)
  351.             return self._cb
  352.  
  353.  
  354.     cb = property(cb)
  355.  
  356. input_manager = InputManager()
  357.